import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
//链表的回文结构
//public class PalindromeList {
//    public boolean chkPalindrome(ListNode A) {
//        // write code here
//        ListNode slow = A;
//        ListNode fast = A;
//        ListNode last = null;
//        //找中间结点
//        while(fast.next != null && fast.next.next != null){
//            fast = fast.next.next;
//            slow = slow.next;
//        }
//        //反转后面结点
//        ListNode cur = slow.next;
//        ListNode curnext = cur.next;
//        while(cur != null){
//            cur.next = slow;
//            slow = cur;
//            cur = curnext;
//            if(cur != null){
//                curnext = cur.next;
//            }
//            if(cur != null && cur.next == null){
//                last = cur;
//            }
//        }
//        //判断回文
//        while(A.next != last && A != last){
//            if(A.val != last.val){
//                return false;
//            }
//            A = A.next;
//            last = last.next;
//        }
//        return true;
//    }
//}

//链表中最后k个结点


/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

//public class Solution {
//    /**
//     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//     *
//     *
//     * @param pHead ListNode类
//     * @param k int整型
//     * @return ListNode类
//     */
//    public ListNode FindKthToTail (ListNode pHead, int k) {
//        // write code here
//        ListNode slow = pHead;
//        ListNode fast = pHead;
//        for(int i = 0; i<k; i++){
//            if(fast == null){
//                return null;
//            }
//            fast = fast.next;
//        }
//        while(fast != null){
//            fast = fast.next;
//            slow = slow.next;
//        }
//        return slow;
//    }
//}


//class Main {
//    public ListNode reverseList(ListNode head) {
//        if(head == null){
//            return null;
//        }
//        if(head.next == null){
//            return head;
//        }
//        ListNode cur = head;
//        ListNode curnext = cur.next;
//        ListNode last = curnext.next;
//        while(curnext != null){
//            curnext.next = cur;
//            cur = curnext;
//            curnext = last;
//            if(last != null){
//                last = last.next;
//            }
//        }
//        return cur;
//    }
//}

//反转链表
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
//class Solution {
//    public ListNode reverseList(ListNode head) {
//        if(head == null){
//            return null;
//        }
//        if(head.next == null){
//            return head;
//        }
//        ListNode slow = head;
//        ListNode cur = slow.next;
//        ListNode curnext = cur.next;
//        while(cur != null){
//            cur.next = slow;
//            slow = cur;
//            cur = curnext;
//            if(cur != null){
//                curnext = cur.next;
//            }
//        }
//        head.next = null;
//        return slow;
//    }
//}

//反转链表
//class Solution {
//    public ListNode reverseList(ListNode head) {
//        if(head == null){
//            return null;
//        }
//        if(head.next == null){
//            return head;
//        }
//        ListNode slow = head;
//        ListNode cur = slow.next;
//        ListNode curnext = cur.next;
//        while(cur != null){
//            cur.next = slow;
//            slow = cur;
//            cur = curnext;
//            if(cur != null){
//                curnext = cur.next;
//            }
//        }
//        head.next = null;
//        return slow;
//    }
//}

//逆波兰表达式求值
//class Solution {
//    public int evalRPN(String[] tokens) {
//        Stack<Integer>s = new Stack<>();
//        int right = 0;
//        int left = 0;
//        for(int i = 0; i<tokens.length; i++){
//            switch(tokens[i]){
//                case "+":{
//                    right = s.pop();
//                    left = s.pop();
//                    s.push(left + right);
//                    break;
//                }
//                case "-":{
//                    right = s.pop();
//                    left = s.pop();
//                    s.push(left - right);
//                    break;
//                }
//                case "*":{
//                    right = s.pop();
//                    left = s.pop();
//                    s.push(left * right);
//                    break;
//                }
//                case "/":{
//                    right = s.pop();
//                    left = s.pop();
//                    s.push(left / right);
//                    break;
//                }
//                default:{
//                    int data = Integer.parseInt(tokens[i]);
//                    s.push(data);
//                    break;
//                }
//            }
//        }
//        return s.pop();
//    }
//}

//public class Main {
//    public static void main(String[] args) {
//        Queue<Integer> q = new LinkedList<>();
//        q.offer(1);
//        q.offer(2);
//        q.offer(3); //从队尾入队列
//        System.out.println(q.size()); //获取队列中有效元素个数
//        System.out.println(q.peek()); //从队头出队列，并将删除的元素返回
//
//        System.out.println(q.poll());//从队头出队列，并将删除的元素返回
//        if (q.isEmpty()){
//            System.out.println("队列空");
//        }else {
//            System.out.println(q.size());
//        }
//    }
//}

    //用队列实现栈
//class MyStack {
//    Queue<Integer> q1 ;
//    Queue<Integer> q2 ;
//
//    public MyStack() {
//        q1 = new LinkedList<>();
//        q2 = new LinkedList<>();
//    }
//
//    public void push(int x) {
//        if (!q2.isEmpty()){
//            q2.offer(x);
//        }else {
//            q1.offer(x);
//        }
//    }
//
//    public int pop() {
//        if (empty()){
//            return -1;
//        }else if (q1.isEmpty()){
//            int size = q2.size();
//            for (int i = 0; i< size-1; i++){
//                q1.offer(q2.poll());
//            }
//            return q2.poll();
//        }else{
//            int size = q1.size();
//            for (int i = 0; i< size-1; i++){
//                q2.offer(q1.poll());
//            }
//            return q1.poll();
//        }
//    }
//
//
//    public int top() {
//        int tmp = 0;
//        if (empty()){
//            return -1;
//        }else if (q1.isEmpty()){
//            int size = q2.size();
//            for (int i = 0; i< size; i++){
//                tmp = q2.poll();
//                q1.offer(tmp);
//            }
//            return tmp;
//        }else{
//            int size = q1.size();
//            for (int i = 0; i< size; i++){
//                tmp = q1.poll();
//                q2.offer(tmp);
//            }
//            return tmp;
//        }
//    }
//
//    public boolean empty() {
//        return q1.isEmpty() && q2.isEmpty();
//    }
//}

//用栈实现队列
//class MyQueue {
//    Stack<Integer>q1;
//    Stack<Integer>q2;
//    public MyQueue() {
//        q1 = new Stack<>();
//        q2 = new Stack<>();
//
//    }
//
//    public void push(int x) {
//        q1.push(x);
//    }
//
//    public int pop() {
//        if (!q2.empty()){
//            return q2.pop();
//        }else if (empty()){
//            return -1;
//        }else {
//            int size = q1.size();
//            for (int j = 0; j < size; j++) {
//                q2.push(q1.pop());
//            }
//            return q2.pop();
//        }
//    }
//
//    public int peek() {
//        if (!q2.empty()){
//            return q2.peek();
//        }else if (empty()){
//            return -1;
//        }else {
//            int size = q1.size();
//            for (int j = 0; j < size; j++) {
//                q2.push(q1.pop());
//            }
//            return q2.peek();
//        }
//    }
//
//    public boolean empty() {
//        return q1.empty() && q2.empty();
//    }
//}

//栈的压入和弹出
import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pushV int整型一维数组
     * @param popV int整型一维数组
     * @return bool布尔型
     */
    public boolean IsPopOrder (int[] pushV, int[] popV) {
        // write code here
        Stack<Integer>hel = new Stack<>();
        int j = 0;
        for(int i=0; i<pushV.length; i++){
            hel.push(pushV[i]);


            while(!hel.empty() && hel.peek() == popV[j]){
                j++;
                hel.pop();
            }
        }
        while(j < popV.length){
            if(popV[j] != hel.pop()){
                return false;
            }
        }
        return true;
    }
}